
/**
 * 把经纬度字符串，转为更易读的：
 * (103.333, 31.332) => (103.333°E, 31.332°N)
 * (-103.333, -31.332) => (103.333°W, 31.332°S)
 * @param {string} lngLatStr
 */
export function convertLngLatToNswe(lngLatStr) {
  const [lng, lat] = lngLatStr.split(', ').map((it) => parseFloat(it));
  const lngEnd = lng > 0 ? 'E' : 'W';
  const latEnd = lat > 0 ? 'N' : 'S';
  return Math.abs(lng) + '°' + lngEnd + ', ' + Math.abs(lat) + '°' + latEnd;
}

/**
 * (103.333°E, 31.332°N) => [103.333, 31.332]
 * (103.333°W, 31.332°S) => [-103.333, -31.332]
 * @param {string} lngLatStr
 */
export function convertNsweLngLatToNums(lngLatStr) {
  const [lngStr, latStr] = lngLatStr.split(', ');
  const lng = lngStr.endsWith('W') ? -parseFloat(lngStr) : parseFloat(lngStr);
  const lat = latStr.endsWith('S') ? -parseFloat(latStr) : parseFloat(latStr);
  return [lng, lat];
}

/**
 * 求两个字符串的最长公共子序列
 * @param {string} str1
 * @param {string} str2
 * @return {number} 最长公共子序列的长度
 */
export function LCS(str1, str2) {
  const m = str1.length;
  const n = str2.length;
  const dp = [new Array(n + 1).fill(0)]; //第一行全是0
  for (let i = 1; i <= m; i++) {
    //一共有m+1行
    dp[i] = [0]; //第一列全是0
    for (let j = 1; j <= n; j++) {
      //一共有n+1列
      if (str1[i - 1] === str2[j - 1]) {
        //注意这里，str1的第一个字符是在第二列中，因此要减1，str2同理
        dp[i][j] = dp[i - 1][j - 1] + 1; //对角＋1
      } else {
        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
      }
    }
  }
  return dp[m][n];
}

/**
 * 防抖函数
 * @param {() => {}} fn
 * @param {number} wait
 * @return {() => {}}
 */
export function debounce(fn, wait) {
  let timer = null;
  return function () {
    if (timer !== null) {
      clearTimeout(timer);
    }
    timer = setTimeout(fn, wait);
  };
}

// return true if number m is between a and b
export function isBetween(m, a, b) {
  if (m >= a && m <= b) {
    return true
  }
  if (m >= b && m <= a) {
    return true
  }
  return false
}

export const removeArrayItem = (array, item) => {
  const index = array.indexOf(item);
  if (index >= 0) {
    array.splice(index, 1);
  }
};
export const replaceArrayItem = (array, newItem, oldItem) => {
  const index = array.indexOf(oldItem);
  if (index >= 0) {
    array[index] = newItem
  }
};

// 集合A - 集合B，arrA 会被修改，arrB不改变
export function arrAsubB(arrA, arrB) {
  arrB.forEach((it) => {
    const ind = arrA.indexOf(it);
    if (ind >= 0) {
      arrA.splice(ind, 1);
    }
  });
  return arrA;
}

// 集合A 与 集合B 的交集
export function arrAintersectB(arrA, arrB) {
  const target = [];
  arrB.forEach((it) => {
    const ind = arrA.indexOf(it);
    if (ind >= 0) {
      target.push(it)
    }
  });
  return target;
}
/**
 * vertsToCircles的反函数
 * @param {{x: number, y: number}[][]} contours
 * @return {[{x: number, y: number}[], number[] (孔的起始顶点索引) ]}
 */
export function circlesToVerts(contours) {
  const points = []
  const holeIndices = []
  let num = 0
  for (let i = 0; i < contours.length; i++) {
    const contour = contours[i]
    num += contour.length
    if (i < contours.length - 1) {
      holeIndices.push(num)
    }
    points.push(...contour)
  }
  return [points, holeIndices]
}

/**
 * @param {[{x: number, y: number}[], number[] (孔的起始顶点索引) ]} verts
 * @return {{x: number, y: number}[][]}
 */
export function vertsToCircles(verts) {
  const points = verts[0]
  const holeIndices = verts[1]
  if (!holeIndices.length) {
    return [points]
  }
  const contours = []
  let pre = 0
  holeIndices.forEach((num, index) => {
    if (index > 0) {
      pre = holeIndices[index - 1]
    }
    contours.push(points.slice(pre, num))
  })
  contours.push(points.slice(holeIndices[holeIndices.length - 1], points.length))
  return contours
}
